home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / support / Tree.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  21.0 KB  |  654 lines
  1. /**********************************************************************************
  2.   * $Header: /private/postgres/src/support/RCS/Tree.c,v 1.2 1991/02/02 15:14:35 sp Exp $
  3.   * Tree.c: The Tree Widget Source File
  4.   *         From:
  5.   *                   The X Window System, 
  6.   *            Programming and Applications with Xt
  7.   *                   OSF/Motif Edition
  8.   *         by
  9.   *                Douglas Young
  10.   *              Prentice Hall, 1990
  11.   *
  12.   *                 Example described on pages: 397-419
  13.   *
  14.   *
  15.   *  Copyright 1989 by Prentice Hall
  16.   *  All Rights Reserved
  17.   *
  18.   * This code is based on the OSF/Motif widget set and the X Window System
  19.   *
  20.   * Permission to use, copy, modify, and distribute this software for 
  21.   * any purpose and without fee is hereby granted, provided that the above
  22.   * copyright notice appear in all copies and that both the copyright notice
  23.   * and this permission notice appear in supporting documentation.
  24.   *
  25.   * Prentice Hall and the author disclaim all warranties with regard to 
  26.   * this software, including all implied warranties of merchantability and fitness.
  27.   * In no event shall Prentice Hall or the author be liable for any special,
  28.   * indirect or cosequential damages or any damages whatsoever resulting from 
  29.   * loss of use, data or profits, whether in an action of contract, negligence 
  30.   * or other tortious action, arising out of or in connection with the use 
  31.   * or performance of this software.
  32.   *
  33.   * Open Software Foundation is a trademark of The Open Software Foundation, Inc.
  34.   * OSF is a trademark of Open Software Foundation, Inc.
  35.   * OSF/Motif is a trademark of Open Software Foundation, Inc.
  36.   * Motif is a trademark of Open Software Foundation, Inc.
  37.   * DEC is a registered trademark of Digital Equipment Corporation
  38.   * HP is a registered trademark of the Hewlett Packard Company
  39.   * DIGITAL is a registered trademark of Digital Equipment Corporation
  40.   * X Window System is a trademark of the Massachusetts Institute of Technology
  41.   **********************************************************************************/
  42.  
  43.  
  44. #include      <X11/Intrinsic.h>
  45. #include      <X11/IntrinsicP.h>
  46. #include      <X11/StringDefs.h>
  47. #include      <X11/CoreP.h>
  48. #include      <X11/CompositeP.h>
  49. #include      <X11/ConstrainP.h>
  50. #include      "Tree.h"
  51. #include      "TreeP.h"
  52. #define   MAX(a,b) ((a) > (b) ? (a) : (b))
  53.  
  54. static void             Initialize();
  55. static void             ConstraintInitialize();
  56. static void             ConstraintDestroy();
  57. static Boolean          ConstraintSetValues();
  58. static Boolean          SetValues();
  59. static XtGeometryResult GeometryManager();
  60. static void             ChangeManaged();
  61. static void             insert_new_node();
  62. static void             delete_node();
  63. static void             new_layout();
  64. static void             Redisplay();
  65. static TreeOffsetPtr    create_offset();
  66. static int              compute_positions();
  67. static void             shift_subtree();
  68. static void             set_positions();
  69. static void             reset();
  70. static Position         current_position();
  71. static void             set_current_position();
  72. static Position         sum_of_positions();
  73.  
  74. static XtResource resources[] = {
  75.  {XtNhorizontalSpace,XtCSpace,XtRDimension,sizeof(Dimension),
  76.    XtOffset(XsTreeWidget, tree.h_min_space), XtRString,"15" },
  77.  {XtNverticalSpace,XtCSpace, XtRDimension,sizeof (Dimension),
  78.    XtOffset(XsTreeWidget, tree.v_min_space), XtRString,"5"  },
  79.  {XtNforeground, XtCForeground, XtRPixel, sizeof (Pixel),
  80.   XtOffset(XsTreeWidget, tree.foreground), XtRString,"Black"},
  81. };
  82.  
  83. static XtResource treeConstraintResources[] = {
  84.  {XtNsuperNode, XtCSuperNode, XtRPointer, sizeof(Widget),
  85.    XtOffset(TreeConstraints, tree.super_node),
  86.    XtRPointer, NULL},
  87. };
  88.  
  89. XsTreeClassRec XstreeClassRec = {
  90.   {
  91.     /* core_class fields  */
  92.     (WidgetClass) &constraintClassRec,/* superclass         */
  93.     "Tree",                           /* class_name         */
  94.     sizeof(XsTreeRec),                /* widget_size        */
  95.     NULL,                             /* class_init         */
  96.     NULL,                             /* class_part_init    */
  97.     FALSE,                            /* class_inited       */    
  98.     Initialize,                       /* initialize         */
  99.     NULL,                             /* initialize_hook    */    
  100.     XtInheritRealize,                 /* realize            */
  101.     NULL,                             /* actions            */
  102.     0,                                /* num_actions        */    
  103.     resources,                        /* resources          */
  104.     XtNumber(resources),              /* num_resources      */
  105.     NULLQUARK,                        /* xrm_class          */
  106.     TRUE,                             /* compress_motion    */    
  107.     TRUE,                             /* compress_exposure  */    
  108.     TRUE,                             /* compress_enterleave*/    
  109.     TRUE,                             /* visible_interest   */
  110.     NULL,                             /* destroy            */
  111.     NULL,                             /* resize             */
  112.     Redisplay,                        /* expose             */
  113.     SetValues,                        /* set_values         */
  114.     NULL,                             /* set_values_hook    */    
  115.     XtInheritSetValuesAlmost,         /* set_values_almost  */
  116.     NULL,                             /* get_values_hook    */    
  117.     NULL,                             /* accept_focus       */
  118.     XtVersion,                        /* version            */    
  119.     NULL,                             /* callback_private   */
  120.     NULL,                             /* tm_table           */
  121.     NULL,                             /* query_geometry     */    
  122.     NULL,                             /* display_accelerator*/
  123.     NULL,                             /* extension          */
  124.   },
  125.   {
  126.     /* composite_class fields */
  127.     GeometryManager,                 /* geometry_manager    */
  128.     ChangeManaged,                   /* change_managed      */
  129.     XtInheritInsertChild,            /* insert_child        */    
  130.     XtInheritDeleteChild,            /* delete_child        */    
  131.     NULL,                            /* extension           */
  132.   },
  133.   { 
  134.     /* constraint_class fields */
  135.    treeConstraintResources,          /* subresources        */
  136.    XtNumber(treeConstraintResources),/* subresource_count   */
  137.    sizeof(TreeConstraintsRec),       /* constraint_size     */
  138.    ConstraintInitialize,             /* initialize          */
  139.    ConstraintDestroy,                /* destroy             */
  140.    ConstraintSetValues,              /* set_values          */
  141.    NULL,                             /* extension           */
  142.    },
  143.   {
  144.     /* Tree class fields */
  145.     0,                               /* ignore              */    
  146.   }
  147. };
  148.  
  149. WidgetClass XstreeWidgetClass = (WidgetClass) &XstreeClassRec;
  150.  
  151. static void Initialize(request, new)
  152.     XsTreeWidget request, new;
  153. {
  154.   Arg       wargs[2];
  155.   XGCValues values;
  156.   XtGCMask  valueMask;
  157.   /*
  158.    * Make sure the widget's width and height are 
  159.    * greater than zero.
  160.    */
  161.   if (request->core.width <= 0)
  162.     new->core.width = 5;
  163.   if (request->core.height <= 0)
  164.     new->core.height = 5;
  165.   /*
  166.    * Create a graphics context for the connecting lines.
  167.    */
  168.   valueMask = GCForeground | GCBackground;
  169.   values.foreground = new->tree.foreground;
  170.   values.background = new->core.background_pixel;
  171.   new->tree.gc = XtGetGC (new, valueMask, &values);  
  172.   /*
  173.    * Create the hidden root widget.
  174.    */
  175.   new->tree.tree_root = (Widget) NULL;
  176.   XtSetArg(wargs[0], XtNwidth, 1);
  177.   XtSetArg(wargs[1], XtNheight, 1);
  178.   new->tree.tree_root = 
  179.           XtCreateWidget("root", widgetClass, new, wargs, 2);
  180.   /*
  181.    * Allocate the tables used by the layout
  182.    * algorithm.
  183.    */
  184.   new->tree.horizontal = create_offset(10);
  185.   new->tree.vertical   = create_offset(10);
  186. } 
  187.  
  188. static void ConstraintInitialize(request, new)
  189.      Widget request, new;
  190. {
  191.   TreeConstraints tree_const = TREE_CONSTRAINT(new);
  192.   XsTreeWidget tw = (XsTreeWidget) new->core.parent;
  193.   /*
  194.    * Initialize the widget to have no sub-nodes.
  195.    */
  196.   tree_const->tree.n_sub_nodes = 0;
  197.   tree_const->tree.max_sub_nodes = 0;
  198.   tree_const->tree.sub_nodes = (WidgetList) NULL;
  199.   tree_const->tree.x = tree_const->tree.y = 0; 
  200.   /*
  201.    * If this widget has a super-node, add it to that 
  202.    * widget' sub-nodes list. Otherwise make it a sub-node of 
  203.    * the tree_root widget.
  204.    */
  205.   if(tree_const->tree.super_node)
  206.     insert_new_node(tree_const->tree.super_node, new);
  207.   else
  208.     if(tw->tree.tree_root)
  209.       insert_new_node(tw->tree.tree_root, new);
  210. } 
  211.  
  212. static Boolean SetValues(current, request, new)
  213.     XsTreeWidget current, request, new;
  214. {
  215.  int       redraw = FALSE;
  216.  XGCValues values;
  217.  XtGCMask  valueMask;
  218.  /*
  219.   * If the foreground color has changed, redo the GC's
  220.   * and indicate a redraw.
  221.   */
  222.  if (new->tree.foreground != current->tree.foreground ||
  223.      new->core.background_pixel !=
  224.                            current->core.background_pixel){
  225.    valueMask         = GCForeground | GCBackground;
  226.    values.foreground = new->tree.foreground;
  227.    values.background = new->core.background_pixel;
  228.    XtReleaseGC(new, new->tree.gc);
  229.    new->tree.gc    = XtGetGC (new, valueMask, &values);   
  230.    redraw = TRUE;     
  231.  }
  232.  /*
  233.   * If the minimum spacing has changed, recalculate the
  234.   * tree layout. new_layout() does a redraw, so we don't
  235.   * need SetValues to do another one.
  236.   */
  237.  if (new->tree.v_min_space != current->tree.v_min_space ||
  238.      new->tree.h_min_space != current->tree.h_min_space){ 
  239.    new_layout(new);
  240.    redraw = FALSE;
  241.  }
  242.  return (redraw);
  243. }
  244.  
  245. static Boolean ConstraintSetValues(current, request, new)
  246.     Widget current, request, new;
  247. {
  248.  TreeConstraints newconst = TREE_CONSTRAINT(new);
  249.  TreeConstraints current_const = TREE_CONSTRAINT(current);
  250.  XsTreeWidget tw = (XsTreeWidget) new->core.parent;
  251.  /*
  252.   * If the super_node field has changed, remove the widget
  253.   * from the old widget's sub_nodes list and add it to the
  254.   * new one.
  255.   */
  256.  if(current_const->tree.super_node !=
  257.                                   newconst->tree.super_node){
  258.    if(current_const->tree.super_node)
  259.      delete_node(current_const->tree.super_node, new);
  260.    if(newconst->tree.super_node)
  261.      insert_new_node(newconst->tree.super_node, new);
  262.    /*
  263.     * If the Tree widget has been realized, 
  264.     * compute new layout.
  265.     */
  266.    if(XtIsRealized(tw))
  267.      new_layout(tw);
  268.   }               
  269.   return (False);
  270. }
  271.  
  272. static void insert_new_node(super_node, node)
  273.      Widget super_node, node;
  274. {
  275.   TreeConstraints super_const = TREE_CONSTRAINT(super_node);
  276.   TreeConstraints node_const = TREE_CONSTRAINT(node);
  277.   int index = super_const->tree.n_sub_nodes;
  278.   
  279.   node_const->tree.super_node = super_node;
  280.   /*
  281.    * If there is no more room in the sub_nodes array, 
  282.    * allocate additional space.
  283.    */  
  284.   if(super_const->tree.n_sub_nodes ==
  285.                              super_const->tree.max_sub_nodes){
  286.     super_const->tree.max_sub_nodes += 
  287.                     (super_const->tree.max_sub_nodes / 2) + 2;
  288.     super_const->tree.sub_nodes = 
  289.      (WidgetList) XtRealloc(super_const->tree.sub_nodes, 
  290.                            (super_const->tree.max_sub_nodes) *
  291.                             sizeof(Widget));
  292.   } 
  293.   /*
  294.    * Add the sub_node in the next available slot and 
  295.    * increment the counter.
  296.    */
  297.   super_const->tree.sub_nodes[index] = node;
  298.   super_const->tree.n_sub_nodes++;
  299. }
  300.  
  301. static void delete_node(super_node, node)
  302.     Widget  super_node, node;
  303. {
  304.   TreeConstraints node_const = TREE_CONSTRAINT(node);
  305.   TreeConstraints super_const;
  306.   int             pos, i;
  307.   /*
  308.    * Make sure the super_node exists.
  309.    */
  310.   if(!super_node) return;  
  311.   
  312.   super_const = TREE_CONSTRAINT(super_node);
  313.   /*
  314.    * Find the sub_node on its super_node's list.
  315.    */
  316.   for (pos = 0; pos < super_const->tree.n_sub_nodes; pos++)
  317.     if (super_const->tree.sub_nodes[pos] == node)
  318.       break;
  319.   if (pos == super_const->tree.n_sub_nodes) return;
  320.   /*
  321.    * Decrement the number of sub_nodes
  322.    */  
  323.   super_const->tree.n_sub_nodes--;
  324.   /*
  325.    * Fill in the gap left by the sub_node.
  326.    * Zero the last slot for good luck.
  327.    */
  328.   for (i = pos; i < super_const->tree.n_sub_nodes; i++) 
  329.     super_const->tree.sub_nodes[i] = 
  330.                             super_const->tree.sub_nodes[i+1];
  331.  super_const->tree.sub_nodes[super_const->tree.n_sub_nodes]=0;
  332. }
  333.  
  334. static void ConstraintDestroy(w) 
  335. #ifdef JUST_LIKE_BOOK  /* Unimportant but perhaps confusing */
  336.      XsTreeWidget w;
  337. #else
  338.      Widget w;
  339. #endif
  340. { 
  341.   TreeConstraints tree_const = TREE_CONSTRAINT(w);
  342.   int i;
  343.  /* 
  344.   * Remove the widget from its parent's sub-nodes list and
  345.   * make all this widget's sub-nodes sub-nodes of the parent.
  346.   */
  347.   if(tree_const->tree.super_node) { 
  348.     delete_node(tree_const->tree.super_node, w);
  349.     for(i=0;i< tree_const->tree.n_sub_nodes; i++)
  350.       insert_new_node(tree_const->tree.super_node, 
  351.                       tree_const->tree.sub_nodes[i]);
  352.   }
  353.   new_layout(w->core.parent);
  354. }
  355.  
  356. static XtGeometryResult GeometryManager(w, request, reply)
  357.     Widget               w;
  358.     XtWidgetGeometry    *request;
  359.     XtWidgetGeometry    *reply;
  360. {
  361.  
  362.  XsTreeWidget tw = (XsTreeWidget) w->core.parent;
  363.  /*
  364.   * No position changes allowed!.
  365.   */
  366.  if ((request->request_mode & CWX && request->x!=w->core.x)
  367.      ||(request->request_mode & CWY && request->y!=w->core.y))
  368.   return (XtGeometryNo);
  369.  /*
  370.   * Allow all resize requests.
  371.   */
  372.  if (request->request_mode & CWWidth)
  373.    w->core.width = request->width;
  374.  if (request->request_mode & CWHeight)
  375.    w->core.height = request->height;
  376.  if (request->request_mode & CWBorderWidth)
  377.    w->core.border_width = request->border_width;
  378.  /*
  379.   *  Compute the new layout based on the new widget sizes;
  380.   */
  381.  new_layout(tw);
  382.  return (XtGeometryYes);
  383. }
  384.  
  385. static void ChangeManaged(tw)
  386.     XsTreeWidget tw;
  387. {
  388.   new_layout(tw);
  389. }
  390.  
  391.  
  392. static void Redisplay (w, event, region)
  393.      XsTreeWidget   w;
  394.      XEvent        *event;
  395.      Region         region;
  396. {
  397.   int              i, j;
  398.   TreeConstraints tree_const;
  399.   Widget          child;
  400.   /*
  401.    * If the Tree widget is visible, visit each managed child.
  402.    */
  403.   if(w->core.visible)
  404.    for (i = 0; i < w -> composite.num_children; i++){
  405.      child = w -> composite.children[i];
  406.      tree_const = TREE_CONSTRAINT(child);
  407.      /*
  408.       * Draw a line between the right edge of each widget
  409.       * and the left edge of each of its sub_nodes. Don't
  410.       * draw lines from the fake tree_root.
  411.       */
  412.      if(child != w->tree.tree_root && 
  413.         tree_const->tree.n_sub_nodes)
  414.        for (j = 0; j < tree_const->tree.n_sub_nodes; j++)
  415.          XDrawLine(XtDisplay(w), XtWindow(w), 
  416.                    w->tree.gc,
  417.                    child->core.x + child->core.width, 
  418.                    child->core.y + child->core.height / 2,
  419.                    tree_const->tree.sub_nodes[j]->core.x,
  420.                    tree_const->tree.sub_nodes[j]->core.y + 
  421.                 tree_const->tree.sub_nodes[j]->core.height/2);
  422.     }
  423. }
  424.  
  425. static void new_layout(tw)
  426.      XsTreeWidget   tw;
  427. {
  428.   /*
  429.    *  Reset the auxiliary tables.
  430.    */
  431.   reset(tw->tree.vertical);
  432.   reset(tw->tree.horizontal);
  433.   /*
  434.    * Compute each widget's x,y position
  435.    */
  436.   compute_positions(tw, tw->tree.tree_root, 0);
  437.   /*
  438.    * Move each widget into place.
  439.    */
  440.   set_positions(tw, tw->tree.tree_root, 0, 0);
  441.   /*
  442.    * Trigger a redisplay of the lines connecting nodes.
  443.    */
  444.   if(XtIsRealized(tw))
  445.     XClearArea(XtDisplay(tw), XtWindow(tw), 0, 0, 0, 0, TRUE);
  446. }
  447.  
  448.  static int compute_positions(tw, w, level)
  449.      XsTreeWidget tw;
  450.      Widget       w;
  451.      long         level;
  452. {
  453.  Position       current_hpos, current_vpos;
  454.  int             i, depth = 0;
  455.  TreeConstraints tree_const = TREE_CONSTRAINT(w);
  456.  /*
  457.   * Get the current positions for this level.
  458.   */
  459.  current_hpos = current_position(tw->tree.horizontal, level);
  460.  current_vpos = current_position(tw->tree.vertical, level);
  461.  /*
  462.   * Set the current horizontal width to the max widths of all
  463.   * widgets at this level.
  464.   */
  465.  set_current_position(tw->tree.horizontal, level, 
  466.                       MAX(current_hpos, w->core.width));
  467.  /*
  468.   * If the node has no sub_nodes, just set the vertical 
  469.   * position to the next available space.
  470.   */
  471.  if(tree_const->tree.n_sub_nodes == 0){
  472.    tree_const->tree.y = current_vpos;
  473.  }
  474.  else {
  475.    Widget          first_kid, last_kid;
  476.    TreeConstraints const1, const2;
  477.    Position        top, bottom;
  478.   /*
  479.    * If the node has sub_nodes, recursively figure the 
  480.    * positions of each sub_node.
  481.    */
  482.    for(i = 0; i < tree_const->tree.n_sub_nodes; i++)
  483.     depth = compute_positions(tw, 
  484.                               tree_const->tree.sub_nodes[i],
  485.                               level + 1);
  486.   /*
  487.    * Now that the vertical positions of all children are 
  488.    * known, find the vertical extent of all sub_nodes.
  489.    */
  490.   first_kid= tree_const->tree.sub_nodes[0];
  491.   last_kid = 
  492.    tree_const->tree.sub_nodes[tree_const->tree.n_sub_nodes-1];
  493.   const1   = TREE_CONSTRAINT(first_kid);
  494.   const2   = TREE_CONSTRAINT(last_kid);
  495.   top      = const1->tree.y + first_kid->core.height / 2; 
  496.   bottom   = const2->tree.y + last_kid->core.height / 2;
  497.   /*
  498.    * Set the node's position to the center of its sub_nodes.
  499.    */
  500.   tree_const->tree.y = (top + bottom)/2 - (w->core.height/ 2);
  501.   /*
  502.    * If this position is less than the next available 
  503.    * position, correct it to be the next available
  504.    * position, calculate the amount by which all sub_nodes
  505.    * must be shifted, and shift the entire sub-tree.
  506.    */
  507.    if(tree_const->tree.y < current_vpos){
  508.      Dimension offset = current_vpos - tree_const->tree.y;
  509.      for(i = 0; i < tree_const->tree.n_sub_nodes; i++)
  510.        shift_subtree(tree_const->tree.sub_nodes[i], offset);
  511.     /*
  512.      * Adjust the next available space at all levels below
  513.      * the current level.
  514.      */
  515.      for(i = level + 1; i <= depth; i++){
  516.        Position pos = current_position(tw->tree.vertical, i);
  517.        set_current_position(tw->tree.vertical, i, pos+offset);
  518.      }
  519.      tree_const->tree.y = current_vpos;
  520.      }
  521.    }
  522.  /*
  523.   * Record the current vertical position at this level.
  524.   */
  525.   set_current_position(tw->tree.vertical, level,
  526.                        tw->tree.v_min_space + 
  527.                        tree_const->tree.y + w->core.height);
  528.   return (MAX(depth, level));
  529. }
  530.  
  531. static void shift_subtree(w, offset)
  532.      Widget     w;
  533.      Dimension  offset;
  534. {
  535.   int             i;
  536.   TreeConstraints tree_const = TREE_CONSTRAINT(w);
  537.   /*
  538.    * Shift the node by the offset.
  539.    */
  540.   tree_const->tree.y += offset; 
  541.   /*
  542.    * Shift each sub-node into place.
  543.    */
  544.   for(i=0; i< tree_const->tree.n_sub_nodes; i++)
  545.     shift_subtree(tree_const->tree.sub_nodes[i], offset);
  546. }
  547.  
  548. static void set_positions(tw, w, level)
  549.      XsTreeWidget tw;
  550.      Widget       w;
  551.      int          level;
  552. {
  553.  int               i;
  554.  Dimension         replyWidth = 0, replyHeight = 0;
  555.  XtGeometryResult  result;
  556.   
  557.  if(w){
  558.   TreeConstraints tree_const = TREE_CONSTRAINT(w);
  559.  /*
  560.   * Add up the sum of the width's of all nodes to this 
  561.   * depth, and use it as the x position.
  562.   */
  563.   tree_const->tree.x = (level * tw->tree.h_min_space) + 
  564.                 sum_of_positions(tw->tree.horizontal, level);
  565.  /*
  566.   * Move the widget into position.
  567.   */
  568.   XtMoveWidget (w, tree_const->tree.x, tree_const->tree.y);
  569.  /*
  570.   * If the widget position plus its width or height doesn't
  571.   * fit in the tree, ask if the tree can be resized.
  572.   */
  573.   if(tw->core.width < tree_const->tree.x + w->core.width ||
  574.      tw->core.height < tree_const->tree.y + w->core.height){
  575.     result = 
  576.       XtMakeResizeRequest(tw, MAX(tw->core.width, 
  577.                                   tree_const->tree.x + 
  578.                                   w->core.width),
  579.                               MAX(tw->core.height, 
  580.                                   tree_const->tree.y + 
  581.                                   w->core.height),
  582.                           &replyWidth, &replyHeight);
  583.     /*
  584.      * Accept any compromise.
  585.      */
  586.      if (result == XtGeometryAlmost)
  587.        XtMakeResizeRequest (tw, replyWidth, replyHeight, 
  588.                              NULL, NULL);
  589.   }
  590.  /*
  591.   * Set the positions of all sub_nodes.
  592.   */
  593.   for(i=0; i< tree_const->tree.n_sub_nodes;i++)
  594.     set_positions(tw, tree_const->tree.sub_nodes[i], level+1);
  595.   }
  596. }
  597.  
  598. static TreeOffsetPtr create_offset(size)
  599.    long size;
  600. {
  601.  TreeOffsetPtr  offset = 
  602.                  (TreeOffsetPtr) XtMalloc(sizeof(TreeOffset));
  603.  offset->size = size;
  604.  offset->array = 
  605.              (Dimension *) XtMalloc(size * sizeof(Dimension));
  606.  return (offset);
  607. }
  608.  
  609. static void reset(offset)
  610.    TreeOffsetPtr offset;
  611. {
  612.   long i;
  613.   for(i=0; i< offset->size; i++)
  614.     offset->array[i] = 0;
  615. }
  616.  
  617. static Position current_position(offset, position)
  618.    TreeOffsetPtr  offset;
  619.    long          position;
  620. {
  621.   if(position >= offset->size)
  622.     return (0);
  623.   return (offset->array[position]);
  624.  }
  625.  
  626. static void set_current_position(offset, index, value)
  627.    TreeOffsetPtr offset;
  628.    int           index;
  629.    Dimension     value;
  630. {
  631.  if(index >= offset->size){
  632.    offset->size = index + index / 2;
  633.    offset->array =
  634.     (Dimension *) XtRealloc(offset->array, 
  635.                             offset->size * sizeof(Dimension));
  636.  }
  637.  offset->array[index] = value;
  638. }
  639.  
  640. static Position sum_of_positions(offset, index)
  641.    TreeOffsetPtr  offset;
  642.    long           index;
  643. {
  644.   int    i;
  645.   Position  sum  = 0;
  646.   long      stop = index;
  647.   if(index > offset->size) 
  648.     stop = offset->size;
  649.   for (i=0;i < stop; i++)
  650.     sum += offset->array[i];
  651.   return (sum);
  652. }
  653.  
  654.